/*******************************************************************************
* Copyright (c) 2000, 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Martin Karpisek (martin.karpisek@gmail.com) - bug 229474
*******************************************************************************/
package org.eclipse.ant.internal.ui.launchConfigurations;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.eclipse.ant.internal.ui.AntUIImages;
import org.eclipse.ant.internal.ui.AntUIPlugin;
import org.eclipse.ant.internal.ui.AntUtil;
import org.eclipse.ant.internal.ui.IAntUIConstants;
import org.eclipse.ant.internal.ui.IAntUIHelpContextIds;
import org.eclipse.ant.internal.ui.model.AntElementNode;
import org.eclipse.ant.internal.ui.model.AntModelContentProvider;
import org.eclipse.ant.internal.ui.model.AntProjectNode;
import org.eclipse.ant.internal.ui.model.AntTargetNode;
import org.eclipse.ant.internal.ui.model.InternalTargetFilter;
import org.eclipse.ant.launching.IAntLaunchConstants;
import org.eclipse.core.externaltools.internal.IExternalToolConstants;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import com.ibm.icu.text.MessageFormat;
/**
* Launch configuration tab which allows the user to choose the targets from an Ant buildfile that will be executed when the configuration is
* launched.
*/
public class AntTargetsTab extends AbstractLaunchConfigurationTab {
private AntTargetNode fDefaultTarget = null;
private AntTargetNode[] fAllTargets = null;
private List<AntTargetNode> fOrderedTargets = null;
private CheckboxTableViewer fTableViewer = null;
private Label fSelectionCountLabel = null;
private Text fTargetOrderText = null;
private Button fOrderButton = null;
private Button fFilterInternalTargets;
private InternalTargetFilter fInternalTargetFilter = null;
private Button fSortButton;
private ILaunchConfiguration fLaunchConfiguration;
private int fSortDirection = 0;
private boolean fInitializing = false;
/**
* Sort direction constants.
*/
public final static int SORT_NONE = 0;
public final static int SORT_NAME = 1;
public final static int SORT_NAME_REVERSE = -1;
public final static int SORT_DESCRIPTION = 2;
public final static int SORT_DESCRIPTION_REVERSE = -2;
/**
* A comparator which can sort targets by name or description, in forward or reverse order.
*/
private class AntTargetsComparator extends ViewerComparator {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
if (!(e1 instanceof AntTargetNode && e2 instanceof AntTargetNode)) {
return super.compare(viewer, e1, e2);
}
if (fSortDirection == SORT_NONE) {
return 0;
}
String string1, string2;
int result = 0;
if (fSortDirection == SORT_NAME || fSortDirection == SORT_NAME_REVERSE) {
string1 = ((AntTargetNode) e1).getLabel();
string2 = ((AntTargetNode) e2).getLabel();
} else {
string1 = ((AntTargetNode) e1).getTarget().getDescription();
string2 = ((AntTargetNode) e2).getTarget().getDescription();
}
if (string1 != null && string2 != null) {
result = getComparator().compare(string1, string2);
} else if (string1 == null) {
result = 1;
} else if (string2 == null) {
result = -1;
}
if (fSortDirection < 0) { // reverse sort
if (result == 0) {
result = -1;
} else {
result = -result;
}
}
return result;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)
*/
@Override
public void createControl(Composite parent) {
Font font = parent.getFont();
Composite comp = new Composite(parent, SWT.NONE);
setControl(comp);
PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IAntUIHelpContextIds.ANT_TARGETS_TAB);
GridLayout topLayout = new GridLayout();
comp.setLayout(topLayout);
GridData gd = new GridData(GridData.FILL_BOTH);
comp.setLayoutData(gd);
comp.setFont(font);
createTargetsTable(comp);
createSelectionCount(comp);
Composite buttonComposite = new Composite(comp, SWT.NONE);
GridLayout layout = new GridLayout();
layout.verticalSpacing = 0;
layout.marginHeight = 0;
layout.marginWidth = 0;
buttonComposite.setLayout(layout);
buttonComposite.setFont(font);
createSortTargets(buttonComposite);
createFilterInternalTargets(buttonComposite);
createVerticalSpacer(comp, 1);
createTargetOrder(comp);
Dialog.applyDialogFont(parent);
}
/**
* Creates the selection count widget
*
* @param parent
* the parent composite
*/
private void createSelectionCount(Composite parent) {
fSelectionCountLabel = new Label(parent, SWT.NONE);
fSelectionCountLabel.setFont(parent.getFont());
fSelectionCountLabel.setText(AntLaunchConfigurationMessages.AntTargetsTab_0_out_of_0_selected_2);
GridData gd = new GridData(GridData.FILL_HORIZONTAL);
fSelectionCountLabel.setLayoutData(gd);
}
/**
* Creates the widgets that display the target order
*
* @param parent
* the parent composite
*/
private void createTargetOrder(Composite parent) {
Font font = parent.getFont();
Label label = new Label(parent, SWT.NONE);
label.setText(AntLaunchConfigurationMessages.AntTargetsTab_Target_execution_order__3);
label.setFont(font);
Composite orderComposite = new Composite(parent, SWT.NONE);
GridData gd = new GridData(GridData.FILL_HORIZONTAL);
orderComposite.setLayoutData(gd);
GridLayout layout = new GridLayout(2, false);
layout.marginHeight = 0;
layout.marginWidth = 0;
orderComposite.setLayout(layout);
orderComposite.setFont(font);
fTargetOrderText = new Text(orderComposite, SWT.MULTI | SWT.WRAP | SWT.BORDER | SWT.V_SCROLL | SWT.READ_ONLY);
fTargetOrderText.setFont(font);
gd = new GridData(GridData.FILL_HORIZONTAL);
gd.heightHint = 40;
gd.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH;
fTargetOrderText.setLayoutData(gd);
fOrderButton = createPushButton(orderComposite, AntLaunchConfigurationMessages.AntTargetsTab__Order____4, null);
gd = (GridData) fOrderButton.getLayoutData();
gd.verticalAlignment = GridData.BEGINNING;
fOrderButton.setFont(font);
fOrderButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleOrderPressed();
}
});
}
/**
* Creates the toggle to filter internal targets from the table
*
* @param parent
* the parent composite
*/
private void createFilterInternalTargets(Composite parent) {
fFilterInternalTargets = createCheckButton(parent, AntLaunchConfigurationMessages.AntTargetsTab_12);
fFilterInternalTargets.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleFilterTargetsSelected();
}
});
}
/**
* Creates the toggle to sort targets in the table
*
* @param parent
* the parent composite
*/
private void createSortTargets(Composite parent) {
fSortButton = createCheckButton(parent, AntLaunchConfigurationMessages.AntTargetsTab_14);
fSortButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
handleSortTargetsSelected();
}
});
}
/**
* The filter targets button has been toggled. If it's been turned on, filter out internal targets. Else, restore internal targets to the table.
*/
private void handleFilterTargetsSelected() {
boolean filter = fFilterInternalTargets.getSelection();
if (filter) {
fTableViewer.addFilter(getInternalTargetsFilter());
} else {
fTableViewer.removeFilter(getInternalTargetsFilter());
}
// Must refresh before updating selection count because the selection
// count's "hidden" reporting needs the content provider to be queried
// first to count how many targets are hidden.
updateSelectionCount();
if (!fInitializing) {
updateLaunchConfigurationDialog();
}
}
private ViewerFilter getInternalTargetsFilter() {
if (fInternalTargetFilter == null) {
fInternalTargetFilter = new InternalTargetFilter();
}
return fInternalTargetFilter;
}
/**
* The button to sort targets has been toggled. Set the tab's sorting as appropriate.
*/
private void handleSortTargetsSelected() {
setSort(fSortButton.getSelection() ? SORT_NAME : SORT_NONE);
}
/**
* Sets the sorting of targets in this tab. See the sort constants defined above.
*
* @param column
* the column which should be sorted on
*/
private void setSort(int column) {
fSortDirection = column;
fTableViewer.refresh();
if (!fInitializing) {
updateLaunchConfigurationDialog();
}
}
/**
* The target order button has been pressed. Prompt the user to reorder the selected targets.
*/
private void handleOrderPressed() {
TargetOrderDialog dialog = new TargetOrderDialog(getShell(), fOrderedTargets.toArray(new AntTargetNode[fOrderedTargets.size()]));
int ok = dialog.open();
if (ok == Window.OK) {
fOrderedTargets.clear();
Object[] targets = dialog.getTargets();
for (int i = 0; i < targets.length; i++) {
fOrderedTargets.add((AntTargetNode) targets[i]);
updateSelectionCount();
updateLaunchConfigurationDialog();
}
}
}
/**
* Creates the table which displays the available targets
*
* @param parent
* the parent composite
*/
private void createTargetsTable(Composite parent) {
Font font = parent.getFont();
Label label = new Label(parent, SWT.NONE);
label.setFont(font);
label.setText(AntLaunchConfigurationMessages.AntTargetsTab_Check_targets_to_e_xecute__1);
final Table table = new Table(parent, SWT.CHECK | SWT.BORDER | SWT.FULL_SELECTION);
GridData data = new GridData(GridData.FILL_BOTH);
int availableRows = availableRows(parent);
data.heightHint = table.getItemHeight() * (availableRows / 20);
data.widthHint = 250;
table.setLayoutData(data);
table.setFont(font);
table.setHeaderVisible(true);
table.setLinesVisible(true);
TableLayout tableLayout = new TableLayout();
ColumnWeightData weightData = new ColumnWeightData(30, true);
tableLayout.addColumnData(weightData);
weightData = new ColumnWeightData(70, true);
tableLayout.addColumnData(weightData);
table.setLayout(tableLayout);
final TableColumn column1 = new TableColumn(table, SWT.NULL);
column1.setText(AntLaunchConfigurationMessages.AntTargetsTab_Name_5);
final TableColumn column2 = new TableColumn(table, SWT.NULL);
column2.setText(AntLaunchConfigurationMessages.AntTargetsTab_Description_6);
// TableLayout only sizes columns once. If showing the targets
// tab as the initial tab, the dialog isn't open when the layout
// occurs and the column size isn't computed correctly. Need to
// recompute the size of the columns once all the parent controls
// have been created/sized.
// HACK Bug 139190
getShell().addShellListener(new ShellAdapter() {
@Override
public void shellActivated(ShellEvent e) {
if (!table.isDisposed()) {
int tableWidth = table.getSize().x;
if (tableWidth > 0) {
int c1 = tableWidth / 3;
column1.setWidth(c1);
column2.setWidth(tableWidth - c1);
}
getShell().removeShellListener(this);
}
}
});
fTableViewer = new CheckboxTableViewer(table);
fTableViewer.setLabelProvider(new TargetTableLabelProvider());
fTableViewer.setContentProvider(new AntModelContentProvider());
fTableViewer.setComparator(new AntTargetsComparator());
fTableViewer.addDoubleClickListener(new IDoubleClickListener() {
@Override
public void doubleClick(DoubleClickEvent event) {
ISelection selection = event.getSelection();
if (!selection.isEmpty() && selection instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection) selection;
Object element = ss.getFirstElement();
boolean checked = !fTableViewer.getChecked(element);
fTableViewer.setChecked(element, checked);
updateOrderedTargets(element, checked);
}
}
});
fTableViewer.addCheckStateListener(new ICheckStateListener() {
@Override
public void checkStateChanged(CheckStateChangedEvent event) {
updateOrderedTargets(event.getElement(), event.getChecked());
}
});
TableColumn[] columns = fTableViewer.getTable().getColumns();
for (int i = 0; i < columns.length; i++) {
final int index = i;
columns[index].addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (fSortButton.getSelection()) {
// index 0 => sort_name (1)
// index 1 => sort_description (2)
int column = index + 1;
if (column == fSortDirection) {
column = -column; // invert the sort when the same column is selected twice in a row
}
setSort(column);
}
}
});
}
}
/**
* Return the number of rows available in the current display using the current font.
*
* @param parent
* The Composite whose Font will be queried.
* @return int The result of the display size divided by the font size.
*/
private int availableRows(Composite parent) {
int fontHeight = (parent.getFont().getFontData())[0].getHeight();
int displayHeight = parent.getDisplay().getClientArea().height;
return displayHeight / fontHeight;
}
/**
* Updates the ordered targets list in response to an element being checked or unchecked. When the element is checked, it's added to the list.
* When unchecked, it's removed.
*
* @param element
* the element in question
* @param checked
* whether the element has been checked or unchecked
*/
private void updateOrderedTargets(Object element, boolean checked) {
if (checked) {
fOrderedTargets.add((AntTargetNode) element);
} else {
fOrderedTargets.remove(element);
}
updateSelectionCount();
updateLaunchConfigurationDialog();
}
/**
* Updates the selection count widget to display how many targets are selected (example, "1 out of 6 selected") and filtered.
*/
private void updateSelectionCount() {
Object[] checked = fTableViewer.getCheckedElements();
String numSelected = Integer.toString(checked.length);
int all = fAllTargets == null ? 0 : fAllTargets.length;
int visible = fTableViewer.getTable().getItemCount();
String total = Integer.toString(visible);
int numHidden = all - visible;
if (numHidden > 0) {
fSelectionCountLabel.setText(MessageFormat.format(AntLaunchConfigurationMessages.AntTargetsTab_13, new Object[] { numSelected,
String.valueOf(all), String.valueOf(numHidden) }));
} else {
fSelectionCountLabel.setText(MessageFormat.format(AntLaunchConfigurationMessages.AntTargetsTab__0__out_of__1__selected_7, new Object[] {
numSelected, total }));
}
fOrderButton.setEnabled(checked.length > 1);
StringBuffer buffer = new StringBuffer();
Iterator<AntTargetNode> iter = fOrderedTargets.iterator();
while (iter.hasNext()) {
buffer.append(iter.next().getTargetName());
buffer.append(", "); //$NON-NLS-1$
}
if (buffer.length() > 2) {
// remove trailing comma
buffer.setLength(buffer.length() - 2);
}
fTargetOrderText.setText(buffer.toString());
}
/**
* Returns all targets in the buildfile.
*
* @return all targets in the buildfile
*/
private AntTargetNode[] getTargets() {
if (fAllTargets == null || isDirty()) {
fAllTargets = null;
fDefaultTarget = null;
setDirty(false);
setErrorMessage(null);
setMessage(null);
final String expandedLocation = validateLocation();
if (expandedLocation == null) {
return fAllTargets;
}
final CoreException[] exceptions = new CoreException[1];
try {
IRunnableWithProgress operation = new IRunnableWithProgress() {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public void run(IProgressMonitor monitor) {
try {
fAllTargets = AntUtil.getTargets(expandedLocation, fLaunchConfiguration);
}
catch (CoreException ce) {
exceptions[0] = ce;
}
}
};
IRunnableContext context = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (context == null) {
context = getLaunchConfigurationDialog();
}
ISchedulingRule rule = null;
if (!ResourcesPlugin.getWorkspace().isTreeLocked()) {
// only set a scheduling rule if not in a resource change callback
rule = AntUtil.getFileForLocation(expandedLocation, null);
}
PlatformUI.getWorkbench().getProgressService().runInUI(context, operation, rule);
}
catch (InvocationTargetException e) {
AntUIPlugin.log("Internal error occurred retrieving targets", e.getTargetException()); //$NON-NLS-1$
setErrorMessage(AntLaunchConfigurationMessages.AntTargetsTab_1);
fAllTargets = null;
return null;
}
catch (InterruptedException e) {
AntUIPlugin.log("Internal error occurred retrieving targets", e); //$NON-NLS-1$
setErrorMessage(AntLaunchConfigurationMessages.AntTargetsTab_1);
fAllTargets = null;
return null;
}
if (exceptions[0] != null) {
IStatus exceptionStatus = exceptions[0].getStatus();
IStatus[] children = exceptionStatus.getChildren();
StringBuffer message = new StringBuffer(exceptions[0].getMessage());
for (int i = 0; i < children.length; i++) {
message.append(' ');
IStatus childStatus = children[i];
message.append(childStatus.getMessage());
}
setErrorMessage(message.toString());
fAllTargets = null;
return fAllTargets;
}
if (fAllTargets == null) {
// if an error was not thrown during parsing then having no targets is valid (Ant 1.6.*)
return fAllTargets;
}
AntTargetNode target = fAllTargets[0];
AntProjectNode projectNode = target.getProjectNode();
setErrorMessageFromNode(projectNode);
for (int i = 0; i < fAllTargets.length; i++) {
target = fAllTargets[i];
if (target.isDefaultTarget()) {
fDefaultTarget = target;
}
setErrorMessageFromNode(target);
}
}
return fAllTargets;
}
private void setErrorMessageFromNode(AntElementNode node) {
if (getErrorMessage() != null) {
return;
}
if (node.isErrorNode() || node.isWarningNode()) {
String message = node.getProblemMessage();
if (message != null) {
setErrorMessage(message);
} else {
setErrorMessage(AntLaunchConfigurationMessages.AntTargetsTab_0);
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
*/
@Override
public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
// do nothing
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)
*/
@Override
public void initializeFrom(ILaunchConfiguration configuration) {
fInitializing = true;
fLaunchConfiguration = configuration;
fOrderedTargets = new ArrayList<>();
setErrorMessage(null);
setMessage(null);
setDirty(true);
boolean hideInternal = false;
try {
hideInternal = fLaunchConfiguration.getAttribute(IAntLaunchConstants.ATTR_HIDE_INTERNAL_TARGETS, false);
}
catch (CoreException e) {
AntUIPlugin.log(e);
}
fFilterInternalTargets.setSelection(hideInternal);
handleFilterTargetsSelected();
int sort = SORT_NONE;
try {
sort = fLaunchConfiguration.getAttribute(IAntLaunchConstants.ATTR_SORT_TARGETS, sort);
}
catch (CoreException e) {
AntUIPlugin.log(e);
}
fSortButton.setSelection(sort != SORT_NONE);
setSort(sort);
String configTargets = null;
String newLocation = null;
try {
configTargets = configuration.getAttribute(IAntLaunchConstants.ATTR_ANT_TARGETS, (String) null);
newLocation = configuration.getAttribute(IExternalToolConstants.ATTR_LOCATION, (String) null);
}
catch (CoreException ce) {
AntUIPlugin.log(AntLaunchConfigurationMessages.AntTargetsTab_Error_reading_configuration_12, ce);
}
if (newLocation == null) {
fAllTargets = null;
initializeForNoTargets();
return;
}
AntTargetNode[] allTargetNodes = getTargets();
if (allTargetNodes == null) {
initializeForNoTargets();
return;
}
String[] targetNames = AntUtil.parseRunTargets(configTargets);
if (targetNames.length == 0) {
fTableViewer.setAllChecked(false);
setExecuteInput(allTargetNodes);
if (fDefaultTarget != null) {
fOrderedTargets.add(fDefaultTarget);
fTableViewer.setChecked(fDefaultTarget, true);
updateSelectionCount();
updateLaunchConfigurationDialog();
}
fInitializing = false;
return;
}
setExecuteInput(allTargetNodes);
fTableViewer.setAllChecked(false);
for (int i = 0; i < targetNames.length; i++) {
for (int j = 0; j < fAllTargets.length; j++) {
if (targetNames[i].equals(fAllTargets[j].getTargetName())) {
fOrderedTargets.add(fAllTargets[j]);
fTableViewer.setChecked(fAllTargets[j], true);
}
}
}
updateSelectionCount();
fInitializing = false;
}
private void initializeForNoTargets() {
setExecuteInput(new AntTargetNode[0]);
fTableViewer.setInput(new AntTargetNode[0]);
fInitializing = false;
}
/**
* Sets the execute table's input to the given input.
*/
private void setExecuteInput(Object input) {
fTableViewer.setInput(input);
updateSelectionCount();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
*/
@Override
public void performApply(ILaunchConfigurationWorkingCopy configuration) {
// attribute added in 3.0, so null must be used instead of false for backwards compatibility
if (fFilterInternalTargets.getSelection()) {
configuration.setAttribute(IAntLaunchConstants.ATTR_HIDE_INTERNAL_TARGETS, true);
} else {
configuration.setAttribute(IAntLaunchConstants.ATTR_HIDE_INTERNAL_TARGETS, (String) null);
}
// attribute added in 3.0, so null must be used instead of 0 for backwards compatibility
if (fSortDirection != SORT_NONE) {
configuration.setAttribute(IAntLaunchConstants.ATTR_SORT_TARGETS, fSortDirection);
} else {
configuration.setAttribute(IAntLaunchConstants.ATTR_SORT_TARGETS, (String) null);
}
if (fOrderedTargets.size() == 1) {
AntTargetNode item = fOrderedTargets.get(0);
if (item.isDefaultTarget()) {
configuration.setAttribute(IAntLaunchConstants.ATTR_ANT_TARGETS, (String) null);
return;
}
} else if (fOrderedTargets.size() == 0) {
configuration.setAttribute(IAntLaunchConstants.ATTR_ANT_TARGETS, (String) null);
return;
}
StringBuffer buff = new StringBuffer();
Iterator<AntTargetNode> iter = fOrderedTargets.iterator();
String targets = null;
while (iter.hasNext()) {
AntTargetNode item = iter.next();
buff.append(item.getTargetName());
buff.append(',');
}
if (buff.length() > 0) {
targets = buff.toString();
}
configuration.setAttribute(IAntLaunchConstants.ATTR_ANT_TARGETS, targets);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName()
*/
@Override
public String getName() {
return AntLaunchConfigurationMessages.AntTargetsTab_Tar_gets_14;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#getImage()
*/
@Override
public Image getImage() {
return AntUIImages.getImage(IAntUIConstants.IMG_TAB_ANT_TARGETS);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#isValid(org.eclipse.debug.core.ILaunchConfiguration)
*/
@Override
public boolean isValid(ILaunchConfiguration launchConfig) {
if (fAllTargets == null || isDirty()) {
if (getErrorMessage() != null && !isDirty()) {
// error in parsing;
return false;
}
// targets not up to date and no error message...we have not parsed recently
initializeFrom(launchConfig);
if (getErrorMessage() != null) {
// error in parsing;
return false;
}
}
setErrorMessage(null);
return super.isValid(launchConfig);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#setDirty(boolean)
*/
@Override
protected void setDirty(boolean dirty) {
// provide package visibility
super.setDirty(dirty);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#activated(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
*/
@Override
public void activated(ILaunchConfigurationWorkingCopy workingCopy) {
if (isDirty()) {
super.activated(workingCopy);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#deactivated(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
*/
@Override
public void deactivated(ILaunchConfigurationWorkingCopy workingCopy) {
if (fOrderedTargets.size() == 0) {
// set the dirty flag so that the state will be reinitialized on activation
setDirty(true);
}
}
private String validateLocation() {
String expandedLocation = null;
String location = null;
IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
try {
location = fLaunchConfiguration.getAttribute(IExternalToolConstants.ATTR_LOCATION, (String) null);
if (location == null) {
return null;
}
expandedLocation = manager.performStringSubstitution(location);
if (expandedLocation == null) {
return null;
}
File file = new File(expandedLocation);
if (!file.exists()) {
setErrorMessage(AntLaunchConfigurationMessages.AntTargetsTab_15);
return null;
}
if (!file.isFile()) {
setErrorMessage(AntLaunchConfigurationMessages.AntTargetsTab_16);
return null;
}
return expandedLocation;
}
catch (CoreException e1) {
if (location != null) {
try {
manager.validateStringVariables(location);
setMessage(AntLaunchConfigurationMessages.AntTargetsTab_17);
return null;
}
catch (CoreException e2) {// invalid variable
setErrorMessage(e2.getStatus().getMessage());
return null;
}
}
setErrorMessage(e1.getStatus().getMessage());
return null;
}
}
protected boolean isTargetSelected() {
return !fOrderedTargets.isEmpty();
}
}